import { _decorator, CCBoolean, CCFloat, Component, Node, tween, Sprite, Vec3, CCInteger, Color } from 'cc';
import { EllipseOrbitController } from './EllipseOrbitController';
const { ccclass, property } = _decorator;

// 攻击状态枚举
enum BallAttackState {
    IDLE,       // 空闲
    PREPARING,  // 准备攻击
    ATTACKING,  // 攻击中
    RETURNING   // 返回中
}

@ccclass('OrbitingBall')
export class OrbitingBall extends Component {
    @property(CCBoolean)
    enableSelfRotation: boolean = true; // 是否启用自转

    @property(CCFloat)
    selfRotationSpeed: number = 1.0; // 球体自转速度

    @property(CCFloat)
    rearrangeScale: number = 1.2; // 重新排列时的缩放比例

    @property(CCFloat)
    rearrangeOpacity: number = 0.8; // 重新排列时的不透明度

    @property(CCInteger)
    maxAttackCount: number = 3; // 最大攻击次数

    private _orbitIndex: number = -1; // 在轨道中的索引
    private _currentAngle: number = 0; // 当前角度
    private _originalScale: Vec3 = new Vec3(1, 1, 1); // 原始缩放
    private _originalOpacity: number = 255; // 原始不透明度
    private _attackCount: number = 3; // 当前攻击次数
    private _attackState: BallAttackState = BallAttackState.IDLE; // 攻击状态
    private _attackProgress: number = 0; // 攻击进度
    private _attackStartPos: Vec3 = new Vec3(); // 攻击起始位置
    private _attackPath: Vec3[] = []; // 攻击路径点数组
    private _currentPathIndex: number = 0; // 当前路径点索引

    start() {
        // 保存原始缩放
        this._originalScale = this.node.scale.clone();

        // 获取并保存原始不透明度
        const sprite = this.node.getComponent(Sprite);
        if (sprite) {
            this._originalOpacity = sprite.color.a;
        }

        // 初始化攻击次数
        this._attackCount = this.maxAttackCount;
    }

    update(deltaTime: number) {
        // 球体自转逻辑
        if (this.enableSelfRotation) {
            this.node.angle += this.selfRotationSpeed * deltaTime;
        }
    }

    // 更新轨道索引
    updateOrbitIndex(index: number) {
        this._orbitIndex = index;
    }

    // 获取轨道索引
    getOrbitIndex(): number {
        return this._orbitIndex;
    }

    // 设置当前角度
    setCurrentAngle(angle: number) {
        this._currentAngle = angle;
    }

    // 获取当前角度
    getCurrentAngle(): number {
        return this._currentAngle;
    }

    // 获取攻击次数
    getAttackCount(): number {
        return this._attackCount;
    }

    // 重新排列开始
    onRearrangeStart() {
        // 只有非基准球应用效果
        if (this._orbitIndex > 0) {
            this.applyRearrangeEffects();
        }
    }

    // 重新排列完成
    onRearrangeComplete() {
        // 只有非基准球应用效果
        if (this._orbitIndex > 0) {
            this.removeRearrangeEffects();
        }
    }

    // 准备攻击
    onAttackPrepare() {
        this._attackState = BallAttackState.PREPARING;
        // 可以在这里添加准备攻击的视觉效果
    }

    // 开始攻击
    onAttackStart(attackPath: Vec3[]) {
        this._attackState = BallAttackState.ATTACKING;
        this._attackProgress = 0;
        this._attackPath = attackPath;
        this._currentPathIndex = 0;
        this._attackStartPos = this.node.position.clone();

        // 添加攻击视觉效果
        this.applyAttackEffects();
    }

    // 更新攻击状态
    updateAttack(deltaTime: number, startPos: Vec3, attackPath: Vec3[]): boolean {
        if (this._attackState !== BallAttackState.ATTACKING) {
            return true; // 攻击完成
        }

        // 如果没有路径点，攻击完成
        if (attackPath.length === 0) {
            return true;
        }

        // 更新攻击进度
        this._attackProgress += deltaTime * 2; // 攻击速度

        // 计算当前路径索引
        const totalPathLength = attackPath.length;
        const pathIndex = Math.floor(this._attackProgress * totalPathLength);

        if (pathIndex >= totalPathLength) {
            // 攻击完成
            this._attackCount--; // 减少攻击次数
            return true; // 攻击完成
        }

        // 设置球体位置
        this.node.setPosition(attackPath[pathIndex].clone());

        // 检查是否击中敌人
        this.checkEnemyHit(attackPath[pathIndex]);

        return false; // 攻击未完成
    }

    // 检查是否击中敌人
    checkEnemyHit(ballPos: Vec3) {
        // 获取轨道控制器
        const orbitController = this.node.parent?.getComponent(EllipseOrbitController);
        if (!orbitController) return;

        // 获取所有敌人
        const enemies = orbitController.getEnemies();

        // 检查是否击中敌人
        for (const enemy of enemies) {
            if (!enemy.isValid) continue;

            // 计算球体与敌人的距离
            const distance = Vec3.distance(ballPos, enemy.position);

            // 如果距离小于阈值，则认为击中敌人
            if (distance < 30) {
                this.hitEnemy(enemy);
                break; // 只攻击一个敌人
            }
        }
    }

    // 命中敌人
    hitEnemy(enemy: Node) {
        if (enemy && enemy.isValid) {
            // 在这里添加命中敌人的逻辑
            // 例如：减少敌人生命值、播放命中效果等
            console.log(`Ball ${this._orbitIndex} hit enemy!`);

            // 假设敌人被消灭
            enemy.destroy();
        }
    }

    // 开始返回
    onReturnStart() {
        this._attackState = BallAttackState.RETURNING;

        // 移除攻击视觉效果
        this.removeAttackEffects();
    }

    // 应用重新排列效果
    applyRearrangeEffects() {
        // 缩放效果
        tween(this.node)
            .to(0.1, { scale: new Vec3(this.rearrangeScale, this.rearrangeScale, 1) })
            .start();

        // 透明度效果
        const sprite = this.node.getComponent(Sprite);
        if (sprite) {
            const color = sprite.color.clone();
            color.a = this.rearrangeOpacity * 255;
            tween(sprite)
                .to(0.1, { color: color })
                .start();
        }
    }

    // 移除重新排列效果
    removeRearrangeEffects() {
        // 恢复缩放
        tween(this.node)
            .to(0.2, { scale: this._originalScale })
            .start();

        // 恢复透明度
        const sprite = this.node.getComponent(Sprite);
        if (sprite) {
            const color = sprite.color.clone();
            color.a = this._originalOpacity;
            tween(sprite)
                .to(0.2, { color: color })
                .start();
        }
    }

    // 应用攻击效果
    applyAttackEffects() {
        // 攻击时放大效果
        tween(this.node)
            .to(0.1, { scale: new Vec3(1.5, 1.5, 1) })
            .start();

        // 攻击时发光效果
        const sprite = this.node.getComponent(Sprite);
        if (sprite) {
            const originalColor = sprite.color.clone();
            tween(sprite)
                .to(0.1, { color: new Color(255, 255, 255, 255) })
                .start();
        }
    }

    // 移除攻击效果
    removeAttackEffects() {
        // 恢复缩放
        tween(this.node)
            .to(0.2, { scale: this._originalScale })
            .start();

        // 恢复颜色
        const sprite = this.node.getComponent(Sprite);
        if (sprite) {
            const originalColor = sprite.color.clone();
            tween(sprite)
                .to(0.2, { color: originalColor })
                .start();
        }
    }

    // 球体被点击时的处理
    onClick() {
        console.log(`Ball ${this._orbitIndex} clicked!`);
        // 可以在这里添加点击后的逻辑
    }
}